// API配置文件
const BASE_URL = 'http://localhost:8080'
// const BASE_URL = 'http://172.20.10.2:8080'

// 获取token
const getToken = () => {
  return uni.getStorageSync('token') || ''
}

// 清除所有缓存数据
const clearAllCache = () => {
  try {
    // 清除登录相关数据
    uni.removeStorageSync('token')
    uni.removeStorageSync('userInfo')
    
    // 清除其他可能的缓存数据
    uni.removeStorageSync('bookings')
    uni.removeStorageSync('rooms')
    uni.removeStorageSync('meetings')
    
    // 清除所有本地存储的key（可选，如果确定要清除所有）
    // const storageInfo = uni.getStorageInfoSync()
    // if (storageInfo.keys && storageInfo.keys.length > 0) {
    //   storageInfo.keys.forEach(key => {
    //     uni.removeStorageSync(key)
    //   })
    // }
    
    console.log('已清除所有缓存数据')
  } catch (error) {
    console.error('清除缓存失败:', error)
  }
}

// 请求拦截器
const requestInterceptor = (config) => {
  // 获取token
  const token = getToken()
  
  // 如果存在token且当前请求不是登录请求也不是匿名请求，则自动添加Authorization头
  if (token && !config.isLogin && !config.isAnonymous) {
    config.headers['Authorization'] = 'Bearer ' + token
  }
  
  return config
}

// 请求封装
const request = (options) => {
  return new Promise((resolve, reject) => {
    // 应用请求拦截器
    const config = requestInterceptor({
      url: BASE_URL + options.url,
      method: options.method || 'GET',
      data: options.data || {},
      headers: {
        'Content-Type': 'application/json',
        ...options.header
      },
      isLogin: options.isLogin || false,
      isAnonymous: options.isAnonymous || false
    })
    
    uni.request({
      url: config.url,
      method: config.method,
      data: config.data,
      header: config.headers,
      success: (res) => {
        if (res.statusCode === 200) {
          // 检查返回数据中的 code 字段，某些接口可能在 statusCode 200 时返回 code 401
          if (res.data && res.data.code === 401) {
            // 如果是匿名请求，不跳转登录页，直接返回错误
            if (config.isAnonymous) {
              reject(new Error(`请求失败: 401 - ${res.data.msg || '未授权'}`))
              return
            }
            // token过期或无效，清除所有缓存并退出登录
            clearAllCache()
            setTimeout(() => {
              uni.reLaunch({
                url: '/pages/login/index'
              })
            }, 100)
            reject(new Error(`请求失败: 401 - ${res.data.msg || '登录已过期'}`))
            return
          }
          resolve(res.data)
        } else if (res.statusCode === 401) {
          // 如果是匿名请求，不跳转登录页，直接返回错误
          if (config.isAnonymous) {
            reject(new Error(`请求失败: ${res.statusCode}`))
            return
          }
          // token过期或无效，清除所有缓存并退出登录
          clearAllCache()
          uni.showToast({
            title: '登录已过期，请重新登录',
            icon: 'none',
            duration: 2000
          })
          setTimeout(() => {
            uni.reLaunch({
              url: '/pages/login/index'
            })
          }, 2000)
          reject(new Error(`请求失败: ${res.statusCode}`))
        } else {
          reject(new Error(`请求失败: ${res.statusCode}`))
        }
      },
      fail: (err) => {
        reject(new Error(`网络请求失败: ${err.errMsg}`))
      }
    })
  })
}

// API接口定义
export const api = {
  // 获取验证码
  getCaptcha: () => {
    return request({
      url: '/captchaImage',
      method: 'GET',
      isLogin: true  // 获取验证码不需要token
    })
  },
  
  // 用户登录
  login: (username, password, code, uuid) => {
    return request({
      url: '/login',
      method: 'POST',
      data: {
        username,
        password,
        code,
        uuid
      },
      isLogin: true  // 标记为登录请求，不自动添加token
    })
  },
  
  // 获取用户信息
  getUserInfo: () => {
    return request({
      url: '/user/info',
      method: 'GET'
    })
  },
  
  // 获取会议室列表
  getRooms: () => {
    return request({
      url: '/rooms',
      method: 'GET'
    })
  },
  
  // 获取会议室列表 (系统接口)
  getRoomList: () => {
    return request({
      url: '/system/room/list',
      method: 'GET',
      isAnonymous: true  // 标记为匿名请求，允许未登录访问
    })
  },
  
  // 获取会议列表
  getMeetings: (params = {}) => {
    return request({
      url: '/meetings',
      method: 'GET',
      data: params
    })
  },
  
  // 创建会议预约
  createBooking: (bookingData) => {
    return request({
      url: '/bookings',
      method: 'POST',
      data: bookingData
    })
  },
  
  // 更新会议预约
  updateBooking: (id, bookingData) => {
    return request({
      url: `/bookings/${id}`,
      method: 'PUT',
      data: bookingData
    })
  },
  
  // 删除会议预约
  deleteBooking: (id) => {
    return request({
      url: `/bookings/${id}`,
      method: 'DELETE'
    })
  },
  
  // 获取我的预约
  getMyBookings: (params = {}) => {
    return request({
      url: '/my/bookings',
      method: 'GET',
      data: params
    })
  },
  
  // 获取用户列表
  getUserList: (params = {}) => {
    return request({
      url: '/system/user/list',
      method: 'GET',
      data: {
        pageSize: 999,
        ...params
      }
    })
  },
  
  // 按日期查询会议列表
  // 返回数据包含以下字段：
  // - need_branch_office: 是否到分局 (0/1)
  // - selected_branches: 选择的分局，多个分局用中文逗号分隔，如："市中区,薛城区,高新区"
  getMeetingsByDate: (theDate, params = {}) => {
    return request({
      url: '/system/yuyue/list',
      method: 'GET',
      data: {
        pageNum: 1,
        pageSize: 10,
        thedate: theDate,
        ...params
      },
      isAnonymous: true  // 标记为匿名请求，允许未登录访问
    })
  },
  
  // 按月份查询会议列表
  // 返回数据包含以下字段：
  // - need_branch_office: 是否到分局 (0/1)
  // - selected_branches: 选择的分局，多个分局用中文逗号分隔，如："市中区,薛城区,高新区"
  getMeetingsByMonth: (startDate, endDate, params = {}) => {
    const data = {
      pageNum: 1,
      pageSize: 999,
      orderByColumn: 'id',
      isAsc: 'desc',
      ...params
    };
    // 只有当 startDate 和 endDate 不为 null 和 undefined 时才添加到请求中
    if (startDate !== null && startDate !== undefined) {
      data.startDate = startDate;
    }
    if (endDate !== null && endDate !== undefined) {
      data.endDate = endDate;
    }
    return request({
      url: '/system/yuyue/list',
      method: 'GET',
      data: data,
      isAnonymous: true  // 标记为匿名请求，允许未登录访问
    })
  },
  
  // 获取用户信息
  getUserInfo: () => {
    return request({
      url: '/getInfo',
      method: 'GET'
    })
  },
  
  // 获取会议预约详情
  getYuyue: (id) => {
    return request({
      url: `/system/yuyue/${id}`,
      method: 'GET'
    })
  },
  
  // 新增会议预约
  // data 参数包含以下字段：
  // - need_branch_office: 是否到分局 (0/1)
  // - selected_branches: 选择的分局，多个分局用中文逗号分隔，如："市中区,薛城区,高新区"
  addYuyue: (data) => {
    return request({
      url: '/system/yuyue',
      method: 'POST',
      data: data
    })
  },
  
  // 更新会议预约（使用 PUT 请求 /system/yuyue）
  // data 参数包含以下字段：
  // - need_branch_office: 是否到分局 (0/1)
  // - selected_branches: 选择的分局，多个分局用中文逗号分隔，如："市中区,薛城区,高新区"
  updateYuyue: (data) => {
    return request({
      url: '/system/yuyue',
      method: 'PUT',
      data: data
    })
  },
  
  // 删除会议预约
  deleteYuyue: (id) => {
    return request({
      url: `/system/yuyue/${id}`,
      method: 'DELETE'
    })
  },
  
  // 修改密码
  updatePassword: (oldPassword, newPassword) => {
    return request({
      url: '/system/user/profile/updatePwd',
      method: 'PUT',
      data: {
        oldPassword: oldPassword,
        newPassword: newPassword
      }
    })
  }
}

// 错误处理工具
export const handleApiError = (error) => {
  console.error('API错误:', error)
  
  // 401错误时清除缓存并退出登录，不显示提示
  if (error.message.includes('请求失败: 401')) {
    clearAllCache()
    // 跳转到登录页
    setTimeout(() => {
      uni.reLaunch({
        url: '/pages/login/index'
      })
    }, 100)
    return ''
  }
  
  let errorMessage = '操作失败，请稍后重试'
  
  if (error.message.includes('网络请求失败')) {
    errorMessage = '网络连接失败，请检查网络设置'
  } else if (error.message.includes('请求失败: 403')) {
    errorMessage = '没有权限执行此操作'
  } else if (error.message.includes('请求失败: 404')) {
    errorMessage = '请求的资源不存在'
  } else if (error.message.includes('请求失败: 500')) {
    errorMessage = '服务器错误，请稍后重试'
  }
  
  uni.showToast({
    title: errorMessage,
    icon: 'none',
    duration: 3000
  })
  
  return errorMessage
}

export default api
